
// // string ToHex(pthread_t tid)
// // {
// //     char id[64];
// //     snprintf(id, sizeof(id), "0x%lx", tid);
// //     return id;
// // }

#include <iostream>
#include <vector>
#include "Thread.hpp"

using namespace ThreadModule;

// 数据不一致
int g_tickets = 10000; // 共享资源，没有保护的

void route(int &tickets)
{
    while (true)
    {
        if(tickets>0)
        {
            usleep(1000);
            printf("get tickets: %d\n", tickets);
            tickets--;
        }
        else
        {
            break;
        }
    }
}

const int num = 4;
int main()
{
    // std::cout << "main： &tickets: " << &g_tickets << std::endl;
    std::vector<Thread<int>> threads;
    // 1. 创建一批线程
    for (int i = 0; i < num; i++)
    {
        std::string name = "thread-" + std::to_string(i + 1);
        threads.emplace_back(route, g_tickets, name);
    }
    // 2. 启动 一批线程
    for (auto &thread : threads)
    {
        thread.Start();
    }
    // 3. 等待一批线程
    for (auto &thread : threads)
    {
        thread.Join();
        std::cout << "wait thread done, thread is: " << thread.name() << std::endl;
    }
    return 0;
}

// using namespace ThreadModule;

// void print(int &cnt)
// {
//     while (cnt)
//     {
//         std::cout << "hello I am myself thread, cnt: " << cnt-- << std::endl;
//         sleep(1);
//     }
// }

// const int num = 10;

// int main()
// {
//     std::vector<Thread<int> > threads;
//     // 1. 创建一批线程
//     for (int i = 0; i < num; i++)
//     {
//         std::string name = "thread-" + std::to_string(i + 1);
//         threads.emplace_back(print, 10, name);
//     }
//     // 2. 启动 一批线程
//     for (auto &thread : threads)
//     {
//         thread.Start();
//     }
//     // 3. 等待一批线程
//     for (auto &thread : threads)
//     {
//         thread.Join();
//         std::cout << "wait thread done, thread is: " << thread.name() << std::endl;
//     }

//     // Thread<int> t1(print, 10);
//     // t1.Start();
//     // std::cout << "name: " << t1.name() << std::endl;
//     // t1.Join();
//     return 0;
// }





// #include <iostream>
// #include <string>
// #include <pthread.h>
// #include <unistd.h>
// using namespace std;

// __thread int tid = 1;

// void *threadrun1(void *args)
// {
//     while (true)
//     {
//         cout << "new thread1, tid: " << tid << "   " << "&tid: " << &tid << endl;
//         tid++;
//         sleep(1); 
//     }
//     return nullptr;
// }

// void *threadrun2(void *args)
// {
//     while (true)
//     {
//         sleep(1); 
//         cout << "new thread2, tid: " << tid << "   " << "&tid: " << &tid << endl;
//         tid++;
//     }
//     return nullptr;
// }

// int main()
// {
//     pthread_t tid1;
//     pthread_t tid2;
//     pthread_create(&tid1, nullptr, threadrun1, nullptr);
//     pthread_create(&tid2, nullptr, threadrun2, nullptr);
//     pthread_detach(tid1);
//     pthread_detach(tid2);
//     for (int i = 0; i < 2; i++)
//     {
//         sleep(2);
//         cout << "main thread, tid: " << tid << "   " << "&tid: " << &tid << endl;
//     }    
//     sleep(2);
//     return 0;
// }


// void* threadrun(void *args)
// {
//     string name = static_cast<const char*>(args);
//     //设置局部变量证明线程栈结构是独立的
//     //注意：不能使用全局变量，因为全局变量没有存储在栈结构中，在全局区中，数据是共享的
//     int g_val = 100;
//     while(true)
//     {
//         sleep(1);
//         cout << name << endl;
//         cout << "g_val: " << g_val << "   " << "&g_val: " << &g_val << endl; 
//         cout << endl;
//     }
//     return nullptr;
// }

// int main()
// {
//     pthread_t tid1;
//     pthread_t tid2;
//     pthread_create(&tid1, nullptr, threadrun, (void*)"new thread1");
//     pthread_create(&tid2, nullptr, threadrun, (void*)"new thread2");
//     //分离新线程
//     pthread_detach(tid1);
//     pthread_detach(tid2);
//     sleep(3);
//     return 0;
// }


// #include <iostream>
// #include <thread> //C++线程库
// #include <unistd.h>
// using namespace std;

// void threadrun(int num)
// {
//     while(num)
//     {
//         cout << "I am a thread, num: " << num << endl;
//         num--;
//         sleep(1);
//     }
// }

// int main()
// {
//     thread t1(threadrun, 1);
//     thread t2(threadrun, 2);
//     thread t3(threadrun, 3);
//     thread t4(threadrun, 4);
//     thread t5(threadrun, 5);

//     while(true)
//     {
//         cout << "I am a main thread "<< endl;
//         sleep(1);
//     }

//     t1.join();
//     t2.join();
//     t3.join();
//     t4.join();
//     t5.join();
//     return 0;
// }

